/**
 * @file lv_fs.c
 *
 */

/*********************
 *      INCLUDES
 *********************/
#include "lv_fs.h"

#include "../misc/lv_assert.h"
#include "lv_ll.h"
#include <string.h>
#include "lv_gc.h"

/*********************
 *      DEFINES
 *********************/

/**********************
 *      TYPEDEFS
 **********************/

/**********************
 *  STATIC PROTOTYPES
 **********************/
static const char *lv_fs_get_real_path(const char *path);

/**********************
 *  STATIC VARIABLES
 **********************/

/**********************
 *      MACROS
 **********************/

/**********************
 *   GLOBAL FUNCTIONS
 **********************/

void _lv_fs_init(void)
{
    _lv_ll_init(&LV_GC_ROOT(_lv_fsdrv_ll), sizeof(lv_fs_drv_t *));
}

bool lv_fs_is_ready(char letter)
{
    lv_fs_drv_t *drv = lv_fs_get_drv(letter);

    if (drv == NULL)
        return false; /*An unknown driver in not ready*/

    if (drv->ready_cb == NULL)
        return true; /*Assume the driver is always ready if no handler provided*/

    return drv->ready_cb(drv);
}

lv_fs_res_t lv_fs_open(lv_fs_file_t *file_p, const char *path, lv_fs_mode_t mode)
{
    if (path == NULL)
    {
        LV_LOG_WARN("Can't open file: path is NULL");
        return LV_FS_RES_INV_PARAM;
    }

    char letter = path[0];
    lv_fs_drv_t *drv = lv_fs_get_drv(letter);

    if (drv == NULL)
    {
        LV_LOG_WARN("Can't open file (%s): unknown driver letter", path);
        return LV_FS_RES_NOT_EX;
    }

    if (drv->ready_cb)
    {
        if (drv->ready_cb(drv) == false)
        {
            LV_LOG_WARN("Can't open file (%s): driver not ready", path);
            return LV_FS_RES_HW_ERR;
        }
    }

    if (drv->open_cb == NULL)
    {
        LV_LOG_WARN("Can't open file (%s): open function not exists", path);
        return LV_FS_RES_NOT_IMP;
    }

    const char *real_path = lv_fs_get_real_path(path);
    void *file_d = drv->open_cb(drv, real_path, mode);

    if (file_d == NULL || file_d == (void *)(-1))
    {
        return LV_FS_RES_UNKNOWN;
    }

    file_p->drv = drv;
    file_p->file_d = file_d;

    if (drv->cache_size)
    {
        file_p->cache = lv_mem_alloc(sizeof(lv_fs_file_cache_t));
        LV_ASSERT_MALLOC(file_p->cache);
        lv_memset_00(file_p->cache, sizeof(lv_fs_file_cache_t));
        file_p->cache->start = UINT32_MAX; /*Set an invalid range by default*/
        file_p->cache->end = UINT32_MAX - 1;
    }

    return LV_FS_RES_OK;
}

lv_fs_res_t lv_fs_close(lv_fs_file_t *file_p)
{
    if (file_p->drv == NULL)
    {
        return LV_FS_RES_INV_PARAM;
    }

    if (file_p->drv->close_cb == NULL)
    {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = file_p->drv->close_cb(file_p->drv, file_p->file_d);

    if (file_p->drv->cache_size && file_p->cache)
    {
        if (file_p->cache->buffer)
        {
            lv_mem_free(file_p->cache->buffer);
        }

        lv_mem_free(file_p->cache);
    }

    file_p->file_d = NULL;
    file_p->drv = NULL;
    file_p->cache = NULL;

    return res;
}

static lv_fs_res_t lv_fs_read_cached(lv_fs_file_t *file_p, char *buf, uint32_t btr, uint32_t *br)
{
    lv_fs_res_t res = LV_FS_RES_OK;
    uint32_t file_position = file_p->cache->file_position;
    uint32_t start = file_p->cache->start;
    uint32_t end = file_p->cache->end;
    char *buffer = file_p->cache->buffer;
    uint16_t buffer_size = file_p->drv->cache_size;

    if (start <= file_position && file_position < end)
    {
        /* Data can be read from cache buffer */
        uint16_t buffer_offset = file_position - start;
        uint32_t buffer_remaining_length = LV_MIN((uint32_t)buffer_size - buffer_offset, (uint32_t)end - file_position);

        if (btr <= buffer_remaining_length)
        {
            /*Data is in cache buffer, and buffer end not reached, no need to read from FS*/
            lv_memcpy(buf, buffer + buffer_offset, btr);
            *br = btr;
        }
        else
        {
            /*First part of data is in cache buffer, but we need to read rest of data from FS*/
            lv_memcpy(buf, buffer + buffer_offset, buffer_remaining_length);

            uint32_t bytes_read_to_buffer = 0;
            if (btr > buffer_size)
            {
                /*If remaining data chuck is bigger than buffer size, then do not use cache, instead read it directly from FS*/
                res = file_p->drv->read_cb(file_p->drv, file_p->file_d, (void *)(buf + buffer_remaining_length),
                                           btr - buffer_remaining_length, &bytes_read_to_buffer);
            }
            else
            {
                /*If remaining data chunk is smaller than buffer size, then read into cache buffer*/
                res = file_p->drv->read_cb(file_p->drv, file_p->file_d, (void *)buffer, buffer_size, &bytes_read_to_buffer);
                file_p->cache->start = file_p->cache->end;
                file_p->cache->end = file_p->cache->start + bytes_read_to_buffer;

                uint16_t data_chunk_remaining = LV_MIN(btr - buffer_remaining_length, bytes_read_to_buffer);
                lv_memcpy(buf + buffer_remaining_length, buffer, data_chunk_remaining);
            }
            *br = LV_MIN(buffer_remaining_length + bytes_read_to_buffer, btr);
        }
    }
    else
    {
        /*Data is not in cache buffer*/
        if (btr > buffer_size)
        {
            /*If bigger data is requested, then do not use cache, instead read it directly*/
            res = file_p->drv->read_cb(file_p->drv, file_p->file_d, (void *)buf, btr, br);
        }
        else
        {
            /*If small data is requested, then read from FS into cache buffer*/
            if (buffer == NULL)
            {
                file_p->cache->buffer = lv_mem_alloc(buffer_size);
                LV_ASSERT_MALLOC(file_p->cache->buffer);
                buffer = file_p->cache->buffer;
            }

            uint32_t bytes_read_to_buffer = 0;
            res = file_p->drv->read_cb(file_p->drv, file_p->file_d, (void *)buffer, buffer_size, &bytes_read_to_buffer);
            file_p->cache->start = file_position;
            file_p->cache->end = file_p->cache->start + bytes_read_to_buffer;

            *br = LV_MIN(btr, bytes_read_to_buffer);
            lv_memcpy(buf, buffer, *br);
        }
    }

    if (res == LV_FS_RES_OK)
    {
        file_p->cache->file_position += *br;
    }

    return res;
}

lv_fs_res_t lv_fs_read(lv_fs_file_t *file_p, void *buf, uint32_t btr, uint32_t *br)
{
    if (br != NULL)
        *br = 0;
    if (file_p->drv == NULL)
        return LV_FS_RES_INV_PARAM;
    if (file_p->drv->read_cb == NULL)
        return LV_FS_RES_NOT_IMP;

    uint32_t br_tmp = 0;
    lv_fs_res_t res;

    if (file_p->drv->cache_size)
    {
        res = lv_fs_read_cached(file_p, (char *)buf, btr, &br_tmp);
    }
    else
    {
        res = file_p->drv->read_cb(file_p->drv, file_p->file_d, buf, btr, &br_tmp);
    }

    if (br != NULL)
        *br = br_tmp;

    return res;
}

lv_fs_res_t lv_fs_write(lv_fs_file_t *file_p, const void *buf, uint32_t btw, uint32_t *bw)
{
    if (bw != NULL)
        *bw = 0;

    if (file_p->drv == NULL)
    {
        return LV_FS_RES_INV_PARAM;
    }

    if (file_p->drv->write_cb == NULL)
    {
        return LV_FS_RES_NOT_IMP;
    }

    uint32_t bw_tmp = 0;
    lv_fs_res_t res = file_p->drv->write_cb(file_p->drv, file_p->file_d, buf, btw, &bw_tmp);
    if (bw != NULL)
        *bw = bw_tmp;

    return res;
}

lv_fs_res_t lv_fs_seek(lv_fs_file_t *file_p, uint32_t pos, lv_fs_whence_t whence)
{
    if (file_p->drv == NULL)
    {
        return LV_FS_RES_INV_PARAM;
    }

    if (file_p->drv->seek_cb == NULL)
    {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = LV_FS_RES_OK;
    if (file_p->drv->cache_size)
    {
        switch (whence)
        {
        case LV_FS_SEEK_SET:
        {
            file_p->cache->file_position = pos;

            /*FS seek if new position is outside cache buffer*/
            if (file_p->cache->file_position < file_p->cache->start || file_p->cache->file_position > file_p->cache->end)
            {
                res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, file_p->cache->file_position, LV_FS_SEEK_SET);
            }

            break;
        }
        case LV_FS_SEEK_CUR:
        {
            file_p->cache->file_position += pos;

            /*FS seek if new position is outside cache buffer*/
            if (file_p->cache->file_position < file_p->cache->start || file_p->cache->file_position > file_p->cache->end)
            {
                res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, file_p->cache->file_position, LV_FS_SEEK_SET);
            }

            break;
        }
        case LV_FS_SEEK_END:
        {
            /*Because we don't know the file size, we do a little trick: do a FS seek, then get new file position from FS*/
            res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, pos, whence);
            if (res == LV_FS_RES_OK)
            {
                uint32_t tmp_position;
                res = file_p->drv->tell_cb(file_p->drv, file_p->file_d, &tmp_position);

                if (res == LV_FS_RES_OK)
                {
                    file_p->cache->file_position = tmp_position;
                }
            }
            break;
        }
        }
    }
    else
    {
        res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, pos, whence);
    }

    return res;
}

lv_fs_res_t lv_fs_tell(lv_fs_file_t *file_p, uint32_t *pos)
{
    if (file_p->drv == NULL)
    {
        *pos = 0;
        return LV_FS_RES_INV_PARAM;
    }

    if (file_p->drv->tell_cb == NULL)
    {
        *pos = 0;
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res;
    if (file_p->drv->cache_size)
    {
        *pos = file_p->cache->file_position;
        res = LV_FS_RES_OK;
    }
    else
    {
        res = file_p->drv->tell_cb(file_p->drv, file_p->file_d, pos);
    }

    return res;
}

lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t *rddir_p, const char *path)
{
    if (path == NULL)
        return LV_FS_RES_INV_PARAM;

    char letter = path[0];
    lv_fs_drv_t *drv = lv_fs_get_drv(letter);

    if (drv == NULL)
    {
        return LV_FS_RES_NOT_EX;
    }

    if (drv->ready_cb)
    {
        if (drv->ready_cb(drv) == false)
        {
            return LV_FS_RES_HW_ERR;
        }
    }

    if (drv->dir_open_cb == NULL)
    {
        return LV_FS_RES_NOT_IMP;
    }

    const char *real_path = lv_fs_get_real_path(path);
    void *dir_d = drv->dir_open_cb(drv, real_path);

    if (dir_d == NULL || dir_d == (void *)(-1))
    {
        return LV_FS_RES_UNKNOWN;
    }

    rddir_p->drv = drv;
    rddir_p->dir_d = dir_d;

    return LV_FS_RES_OK;
}

lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t *rddir_p, char *fn)
{
    if (rddir_p->drv == NULL || rddir_p->dir_d == NULL)
    {
        fn[0] = '\0';
        return LV_FS_RES_INV_PARAM;
    }

    if (rddir_p->drv->dir_read_cb == NULL)
    {
        fn[0] = '\0';
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = rddir_p->drv->dir_read_cb(rddir_p->drv, rddir_p->dir_d, fn);

    return res;
}

lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t *rddir_p)
{
    if (rddir_p->drv == NULL || rddir_p->dir_d == NULL)
    {
        return LV_FS_RES_INV_PARAM;
    }

    if (rddir_p->drv->dir_close_cb == NULL)
    {
        return LV_FS_RES_NOT_IMP;
    }

    lv_fs_res_t res = rddir_p->drv->dir_close_cb(rddir_p->drv, rddir_p->dir_d);

    rddir_p->dir_d = NULL;
    rddir_p->drv = NULL;

    return res;
}

void lv_fs_drv_init(lv_fs_drv_t *drv)
{
    lv_memset_00(drv, sizeof(lv_fs_drv_t));
}

void lv_fs_drv_register(lv_fs_drv_t *drv_p)
{
    /*Save the new driver*/
    lv_fs_drv_t **new_drv;
    new_drv = _lv_ll_ins_head(&LV_GC_ROOT(_lv_fsdrv_ll));
    LV_ASSERT_MALLOC(new_drv);
    if (new_drv == NULL)
        return;

    *new_drv = drv_p;
}

lv_fs_drv_t *lv_fs_get_drv(char letter)
{
    lv_fs_drv_t **drv;

    _LV_LL_READ(&LV_GC_ROOT(_lv_fsdrv_ll), drv)
    {
        if ((*drv)->letter == letter)
        {
            return *drv;
        }
    }

    return NULL;
}

char *lv_fs_get_letters(char *buf)
{
    lv_fs_drv_t **drv;
    uint8_t i = 0;

    _LV_LL_READ(&LV_GC_ROOT(_lv_fsdrv_ll), drv)
    {
        buf[i] = (*drv)->letter;
        i++;
    }

    buf[i] = '\0';

    return buf;
}

const char *lv_fs_get_ext(const char *fn)
{
    size_t i;
    for (i = strlen(fn); i > 0; i--)
    {
        if (fn[i] == '.')
        {
            return &fn[i + 1];
        }
        else if (fn[i] == '/' || fn[i] == '\\')
        {
            return ""; /*No extension if a '\' or '/' found*/
        }
    }

    return ""; /*Empty string if no '.' in the file name.*/
}

char *lv_fs_up(char *path)
{
    size_t len = strlen(path);
    if (len == 0)
        return path;

    len--; /*Go before the trailing '\0'*/

    /*Ignore trailing '/' or '\'*/
    while (path[len] == '/' || path[len] == '\\')
    {
        path[len] = '\0';
        if (len > 0)
            len--;
        else
            return path;
    }

    size_t i;
    for (i = len; i > 0; i--)
    {
        if (path[i] == '/' || path[i] == '\\')
            break;
    }

    if (i > 0)
        path[i] = '\0';

    return path;
}

const char *lv_fs_get_last(const char *path)
{
    size_t len = strlen(path);
    if (len == 0)
        return path;

    len--; /*Go before the trailing '\0'*/

    /*Ignore trailing '/' or '\'*/
    while (path[len] == '/' || path[len] == '\\')
    {
        if (len > 0)
            len--;
        else
            return path;
    }

    size_t i;
    for (i = len; i > 0; i--)
    {
        if (path[i] == '/' || path[i] == '\\')
            break;
    }

    /*No '/' or '\' in the path so return with path itself*/
    if (i == 0)
        return path;

    return &path[i + 1];
}
/**********************
 *   STATIC FUNCTIONS
 **********************/

/**
 * Skip the driver letter and the possible : after the letter
 * @param path path string (E.g. S:/folder/file.txt)
 * @return pointer to the beginning of the real path (E.g. /folder/file.txt)
 */
static const char *lv_fs_get_real_path(const char *path)
{
    path++; /*Ignore the driver letter*/
    if (*path == ':')
        path++;

    return path;
}
